﻿//获取原图像文件名
function getfilename(str){
           var pos=str.lastIndexOf(".");
		  return str.substring(0,pos);
    }

//创建输出路径
function createout(path,name){
    var out = new Folder(path + "\\"+name);
    if (!out.exists) {
        out.create();
         }
    }

//生成从minNum到maxNum的随机整数
function randomNum(minNum,maxNum){ 
            return parseInt(Math.random()*(maxNum-minNum+1)+minNum,10); 
     }
  
//生成从minNum到maxNum的随机小数
 function randfloat(minNum,maxNum){
            return   Math.random() * (maxNum -minNum) + minNum;
     }
 
//计算区域中心点
function gravity(region){
             var area=0.0;
             var n=region.length;
             var center=[0.0,0.0];
             for(var i=0;i<n-1;i++){
                 area+=(region[i][0]*region[i+1][1]-region[i+1][0]*region[i][1])/2;                 
                 center[0]+=(region[i][0]*region[i+1][1]-region[i+1][0]*region[i][1])*(region[i][0]+region[i+1][0]);
                 center[1]+=(region[i][0]*region[i+1][1]-region[i+1][0]*region[i][1])*(region[i][1]+region[i+1][1]);
                 }
                 area+=(region[n-1][0]*region[0][1]-region[0][0]*region[n-1][1])/2;                 
                 center[0]+=(region[n-1][0]*region[0][1]-region[0][0]*region[n-1][1])*(region[n-1][0]+region[0][0]);
                 center[1]+=(region[n-1][0]*region[0][1]-region[0][0]*region[n-1][1])*(region[n-1][1]+region[0][1]);
                 center[0]/=6*area;
                 center[1]/=6*area;
                 return center;
    }

//两个坐标比较
function Cmp(p1, p2,center) {
       if (p1[0] >=0&& p2[0]<0) 
                return true;
       if (p1[0] ==0 && p2[0]==0) 
               return (p1[1] > p2[1]);
       var det=(p1[0]-center[0])*(p2[1]-center[1])-(p2[0]-center[0])*(p1[1]-center[1]);
       if(det<0) return true;
       if(det>0) return false;
       var d1=(p1[0]-center[0])*(p1[0]-center[0])+(p1[1]-center[1])*(p1[1]-center[1]);
       var d2=(p2[0]-center[0])*(p2[0]-center[0])+(p2[1]-center[1])*(p2[1]-center[1]); 
       return d1>d2;
   }     

//坐标点排序
function sortdots(region,center){
    var len = region.length;
     for (var i = 0; i < len - 1; i++) {
       for (var j = 0; j < len - 1 - i; j++) {
         if (!Cmp(region[j],region[j + 1],center)) {
           var tmp = region[j];
           region[j] = region[j + 1];
           region[j + 1] = tmp;
         }
       }
     }
    }

//随机生成选区区域
function randomregion(x,maxwidth,maxheight){
         maxwidth.convert("px");maxheight.convert("px");
         if(x!=-1){
                 //打开其它图像
                 open(fileList[x]);
                 tmpdoc=app.activeDocument;
                 tmpwidth=tmpdoc.width;tmpwidth.convert("px");
                 tmpheight=tmpdoc.height;tmpheight.convert("px");
                 maxwidth=Math.min(maxwidth,tmpwidth);
                 maxheight=Math.min(maxheight,tmpheight);
                 tmpdoc.close(SaveOptions.DONOTSAVECHANGES);
             }
         var length=Math.floor(Math.min(maxwidth/150,maxheight/150));
         var dots=randomNum(3,8);     
         var region=[]; 
for(var i=0;i<dots;i++){
    region[i]=[randomNum (0, Math.floor(maxwidth)),randomNum (0,Math.floor(maxheight))];
    }         
         /*
         region[0]=[randomNum (0, Math.floor(maxwidth*4/5)),randomNum (0,Math.floor(maxheight*4/5))];
         for(var i=1;i<=Math.floor(dots/2);i++){
                   var tmp=[];
                   var x=randomNum(15,25);var y=randomNum(15,25);                                  
                   tmp[0]=region[i-1][0]+x*length; 
                   var up=Math.round(Math.random());
                   if(up)
                   tmp[1]=region[i-1][1]-y*length;
                   else
                   tmp[1]=region[i-1][1]+y*length;                 
                   if(tmp[0]>maxwidth) tmp[0]=maxwidth;
                   if(tmp[1]<0) tmp[1]=0;
                   if(tmp[1]>maxheight) tmp[1]=maxheight;
                   region[i]=tmp;
             }
         for(var i=Math.floor(dots/2)+1;i<dots;i++){
                   var tmp=[];
                   var x=randomNum(15,20);var y=randomNum(15,20);
                   tmp[0]=region[i-1][0]-x*length;
                   var up=Math.round(Math.random());
                   if(up)
                   tmp[1]=region[i-1][1]-y*length;
                   else
                   tmp[1]=region[i-1][1]+y*length; 
                   if(tmp[0]<0) tmp[0]=0;
                   if(tmp[1]<0) tmp[1]=0;
                   if(tmp[1]>maxheight) tmp[1]=maxheight;
                   region[i]=tmp;               
             }*/
         var center=gravity (region);
         sortdots (region, center);      
         return region;
    }

//随机选择滤波器过滤
function randomfliter(document,region,rotate,scale,parameter){
       var layer=document.activeLayer;
       //通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
       document.selection.select(region, SelectionType.REPLACE, 0, true); 
       document.selection.resize(scale[0],scale[1],AnchorPosition.MIDDLECENTER);
       document.selection.rotate(rotate[0],AnchorPosition.MIDDLECENTER);
       document.selection.selectBorder(1);
       //随机选择滤波器       
       var rand=randomNum (1, 9);    
       //滤波器参数用parameter保存，parameter[0]保存滤波器代号，1--保存滤波器参数
       switch(rand){
           case 1:{/*模糊滤波器，无参数*/
               parameter[0]=1;//代号
               layer.applyBlur();
                    }break;
           case 2:{/*Blur more滤波器，无参数*/
               parameter[0]=2;//代号
               layer.applyBlurMore();
                    }break;
           case 3:{/*均值滤波器，无参数*/
               parameter[0]=3;//代号
               layer.applyAverage();
                    }break;
           case 4:{/*高斯模糊滤波器，单参数：半径*/
               parameter[0]=4;//代号
               parameter[1]=randfloat(0.1,250.0).toFixed (1);//半径（浮点数数值型 范围：[0.1,250.0]）
               layer.applyGaussianBlur(parameter[1]);
                    }break;
           case 5:{/*镜头模糊滤波器，多参数：深度映射，模糊焦距，反相，光圈形状，光圈半径，叶片弯度，旋转，镜面高光亮度，镜面高光阈值，杂色数量，杂色分布，杂色是否单色*/
               parameter[0]=5;//代号
               switch(randomNum (0,1)){//深度映射模式（4种：高亮度，无，透明度，图层蒙版）
                      case 0: parameter[1]=DepthMapSource.IMAGEHIGHLIGHT;break;
                      case 1: parameter[1]=DepthMapSource.NONE;break;
                      //case 2: parameter[1]=DepthMapSource.TRANSPARENCYCHANNEL;break;//应用太卡
                      //case 3:parameter[1]=DepthMapSource.LAYERMASK;break;//应用太卡
                      default: parameter[1]=DepthMapSource.NONE;break;
                            }
               if(parameter[1]==DepthMapSource.NONE) parameter[2]=0;
               else parameter[2]=randomNum (0, 255);//模糊焦距
               //if(Math.round(Math.random()))parameter[3]=true;else //true太卡
               parameter[3]=false; //是否反相
               switch(randomNum (0,5)){//光圈形状（6种：六角形，七角形，八角形，五角形，四边形，三角形）
                           case 0:parameter[4]=Geometry.HEXAGON;break;
                           case 1:parameter[4]=Geometry.HEPTAGON;break;
                           case 2:parameter[4]=Geometry.OCTAGON;break;
                           case 3:parameter[4]=Geometry.PENTAGON;break;
                           case 4:parameter[4]=Geometry.SQUARE;break;
                           case 5:parameter[4]=Geometry.TRIANGLE;break;
                           default:parameter[4]=Geometry.HEXAGON;break;
                           }
               parameter[5]=randomNum(0,100);//光圈半径(整数数值型 范围[0,100])
               parameter[6]= randomNum(0,100);//叶片弯度(整数数值型 范围[0,100])
               parameter[7]=randomNum(0,360);//旋转角度(整数数值型 范围[0,360])
               parameter[8]=randomNum(0,100);//镜面高光亮度(整数数值型 范围[0,100])
               parameter[9]=randomNum(0,100);//镜面高光阈值(整数数值型 范围[0,100])
               parameter[10]=randomNum(0,255);//杂色数量(整数数值型 范围[0,255])
               switch(randomNum (0,1)){//杂色分布模式（两种：高斯分布，平均分布）
                           case 0:parameter[11]=NoiseDistribution.GAUSSIAN;break;
                           case 1:parameter[11]=NoiseDistribution.UNIFORM;break;
                           default:parameter[11]=NoiseDistribution.UNIFORM;break;
               } 
               if(Math.round(Math.random()))parameter[12]=false;//杂色是否为单色
               else parameter[12]=true;
               layer.applyLensBlur(parameter[1],parameter[2],parameter[3],parameter[4],parameter[5],parameter[6],
                                            parameter[7],parameter[8],parameter[9],parameter[10],parameter[11],parameter[12]);
                     }break;
           case 6:{/*运动模糊滤波器，多参数：旋转角度，旋转半径*/
               parameter[0]=6;//代号
               parameter[1]=randomNum (-360, 360);//旋转角度（整数数值型 范围：[-360,360]）
               parameter[2]=randomNum (1, 999);//旋转半径（整数数值型 范围[1,999]）
               layer.applyMotionBlur(parameter[1],parameter[2]);
                      }break;
           case 7:{/*径向模糊滤波器，多参数：数量，模糊方法，模糊品质，模糊中心*/
               parameter[0]=7;//代号
               parameter[1]=randomNum (1, 100);//数量 （整数数值型 范围[1,100]）
               switch(randomNum (0,1)){//模糊方法：1.旋转 2.缩放
                           case 0:parameter[2]=RadialBlurMethod.SPIN;break;
                           case 1:parameter[2]=RadialBlurMethod.ZOOM;break;
                           default:parameter[2]=RadialBlurMethod.SPIN;break;
                             }
               switch(randomNum (0, 2)){//模糊品质：1. 最好2.草图 3.好
                           case 0:parameter[3]=RadialBlurQuality.BEST;break;
                           case 1:parameter[3]=RadialBlurQuality.DRAFT;break;
                           case 2:parameter[3]=RadialBlurQuality.GOOD;break;
                           default:parameter[3]=RadialBlurQuality.BEST;break;
                              }
               parameter[4]=gravity (region) //旋转中心，在这里用gravity函数计算选区中心作为参数
               parameter[4][0]=parseFloat(parameter[4][0]).toFixed (2);parameter[4][1]=parseFloat(parameter[4][1]).toFixed (2);//保留两位小数
               layer.applyRadialBlur(parameter[1],parameter[2],parameter[3],parameter[4]); 
                      }break;
           case 8:{/*智能模糊滤波器，多参数：半径，阈值，模糊品质，模糊模式方法*/
               parameter[0]=8;//代号
               parameter[1]=randfloat(0.1,100.0).toFixed (1);//半径（浮点数数值型，范围[0.1,100]）
               parameter[2]=randfloat(0.1,100.0).toFixed (1);//阈值（浮点数数值型，范围[0.1,100]）
               switch(randomNum (0, 2)){//模糊品质：1. 高2.低 3.中等
                         case 0:parameter[3]=SmartBlurQuality.HIGH;break;
                         case 1:parameter[3]=SmartBlurQuality.LOW;break;
                         case 2:parameter[3]=SmartBlurQuality.MEDIUM;break;
                         default:parameter[3]=SmartBlurQuality.MEDIUM;break;
                             }
               switch(randomNum(0,2)){//模糊模式方法：1.只保留边缘线 2.强化描边 3.普通
                         case 0:parameter[4]=SmartBlurMode.EDGEONLY;break;
                         case 1:parameter[4]=SmartBlurMode.OVERLAYEDGE;break;
                         case 2:parameter[4]=SmartBlurMode.NORMAL;break;
                         default:parameter[4]=SmartBlurMode.OVERLAYEDGE;break;
                             }
                layer.applySmartBlur(parameter[1],parameter[2],parameter[3],parameter[4]);  
                  }break;
           case 9:{/*自定义滤波器，多参数：卷积，缩放，位移*/
               parameter[0]=9;//代号 
               parameter[1]=[];
               for(var i=0;i<25;i++){//卷积参数，用于调整像素亮度（整数数值型 范围[-999,999]）
                   parameter[1][i]=randomNum (-10, 10);
                   }
               parameter[2]=randomNum (1, 20);//缩放，调整像素亮度，新亮度=原亮度/parameter[2]（整数数值型 范围([1,999]）
               parameter[3]=randomNum (-5, 5);//位移，调整像素亮度，新亮度=原亮度-parameter[3]（整数数值型 范围([-999,999]）
               layer.applyCustomFilter(parameter[1],parameter[2],parameter[3]);
                      }break;
           default :{parameter[0]=1;layer.applyBlur();}//默认使用模糊滤波器
                          break;
           }    
      document.selection.deselect();
    }

//拼接图像
function jointpic(x,doc,region,rotate,scale,parameter){
        //随机打开其它图像
        open(fileList[x]);
        tmpdoc=app.activeDocument;
        //随机选取图片区域
        tmpdoc.selection.select(region, SelectionType.REPLACE, 0, true); 
        tmpdoc.selection.copy();
        tmpdoc.close(SaveOptions.DONOTSAVECHANGES);
        //拼接至图像区域
        doc.selection.select(region, SelectionType.REPLACE, 0, true);
        doc.paste();
        //随机进行缩放和旋转
         doc.selection.select(region, SelectionType.REPLACE, 0, true);         
         if(Math.round(Math.random())){//缩放
              scale[0]=randomNum (30, 100);scale[1]=randomNum (30, 100);  
              doc.selection.resizeBoundary(scale[0],scale[1],AnchorPosition.MIDDLECENTER);
        
             }
         if(Math.round(Math.random())){//旋转
             rotate[0]=randomNum (1,359);
             doc.selection.rotateBoundary(rotate[0],AnchorPosition.MIDDLECENTER);
            }
        //边界随机进行滤波        
        //randomfliter (doc, region,rotate,scale,parameter);
        //合并图层
        doc.flatten();
    }

//定义变量inFolder，outFolder用来表示输入文件夹和输出文件夹，不能为不存在的文件夹
var inFolder = Folder("D:\\学习\\大三上\\项目\\ps脚本项目\\test\\inPic\\");
var outFolder=Folder("D:\\学习\\大三上\\项目\\ps脚本项目\\test\\outPic\\");
var falsifyfile="falsify";
var markfile="mark";
//var operatorfile="operator";
 if (!outFolder.exists) {
        outFolder.create();
         }
createout(outFolder,falsifyfile);
createout(outFolder,markfile);
//createout(outFolder,operatorfile);

//操作信息标记
var isjoint=0; //是否为区域拼接
var rotate=[0];//旋转角度,角度为0，则未旋转
var scale=[100,100];//缩放比例，比例100则未缩放
var parameter=[];//滤波参数
var text="";//操作信息内容

 //篡改图片格式
//var jpegSaveOption = new JPEGSaveOptions();
//jpegSaveOption.quality = 10;
 //标记图像格式
 var pngSaveOption=new PNGSaveOptions();
var bitmapconversionoption=new BitmapConversionOptions(); 

//创建标记图像颜色
var white = new SolidColor();
white.rgb["hexValue"] = "ffffff"; 
var black = new SolidColor(); 
black.rgb["hexValue"] = "000000";

//定义一个变量[fileList]，用来表示使用[getFiles]命令获得的文件夹下的所有文档。
var fileList=inFolder.getFiles();
//创建一个for循环，用来遍历[fileList]数组里面的所有文档。
for (var i=0; i<fileList.length; i++) 
{
        if (fileList[i] instanceof File) 
        {
            open(fileList[i]);
            var document=app.activeDocument;   
            //初始化操作标记            
            isjoint=9;
            rotate=[0];
            scale=[100,100];
            parameter=[];
            text="";
            //随机决定滤波或拼接
            //isjoint=randomNum(0,9);
          //确定[region]，表示一定范围的区域
            var region; 
            if(isjoint<5){
            region=randomregion(-1,document.width,document.height);
            randomfliter (document, region,rotate,scale,parameter);
            }            
            else{
                     var x=0;
                     do{
                         x=randomNum (0, fileList.length-1);
                          }while(x==i);  
                     region=randomregion(x,document.width,document.height);
                     try{
                     //区域拼接           
                     jointpic (x,document,region,rotate,scale,parameter); }
                 catch(e){
                      alert(region);
                      region=randomregion(x,document.width,document.height);
                      jointpic (x,document, region, rotate, scale, parameter);
                     }
                   }         
            //设置输出图片文件名,操作信息文件名
            //var falsifyOut = new File(outFolder+"\\"+falsifyfile+"\\"+getfilename(fileList[i].name)+".jpeg");
            var falsifyOut = new File(outFolder+"\\"+falsifyfile+"\\"+getfilename(fileList[i].name)+".png");
            var markOut=new File(outFolder+"\\"+markfile+"\\"+getfilename(fileList[i].name)+".png");    
            //var fileOut = new File(outFolder+"\\"+operatorfile+"\\"+getfilename (fileList[i].name)+".txt");    
            //篡改图片将被存储为
            //document.saveAs (falsifyOut,jpegSaveOption);    
            document.saveAs (falsifyOut,pngSaveOption);  

            //标记图像使用[Documents.add]命令创建一个新文档,创建为位图
            app.documents.add(document.width, document.height, 72, getfilename(fileList[i].name),NewDocumentMode.BITMAP,DocumentFill.TRANSPARENT, 1);
            //关闭原图像文档
            document.close(SaveOptions.DONOTSAVECHANGES);    
            //开始标记
            markdocument = app.activeDocument;   
            markdocument.selection.selectAll(); 
            markdocument.selection.fill(black); 
            markdocument.selection.deselect(); 
            markdocument.selection.select(region, SelectionType.REPLACE, 0, true); 
            markdocument.selection.resizeBoundary(scale[0],scale[1],AnchorPosition.MIDDLECENTER);
            markdocument.selection.rotateBoundary(rotate[0],AnchorPosition.MIDDLECENTER);
            //markdocument.selection.selectBorder(1);
            markdocument.selection.fill(white); 
            markdocument.selection.deselect();
            //标记图像存储为.png 
            markdocument.saveAs(markOut,pngSaveOption);
            //关闭标记图像文档 
            markdocument.close(SaveOptions.DONOTSAVECHANGES);    
            /*
           //记录操作信息            
            fileOut.open("w","TEXT","????");
            if(isjoint<5){
                 text+="joint 0\nrotate 0\nscale 0\n" ;               
                }
            else{
                 text+="joint 1\n";
                 if(rotate[0])
                 text+="rotate 1\n";
                 else
                 text+="rotate 0\n";
                 if(scale[0]<100||scale[1]<100)
                  text+="scale 1\n";                 
                 else
                  text+="scale 0\n";
                }
            switch(parameter[0]){
                case 1:{text+="blur [";}break;       
                case 2:{text+="blur more [";}break;   
                case 3:{text+="average [";}break;   
                case 4:{text+="gaussian [";}break;   
                case 5:{text+="lens [";}break;   
                case 6:{text+="motion [";}break;   
                case 7:{text+="radial [";}break;   
                case 8:{text+="smart [";}break;   
                case 9:{text+="custom [";}break;
                }
            for(var j=1;j<parameter.length-1;j++){
                 text+=parameter[j]+",";                
                }
            if(parameter.length>1)
            text+=parameter[parameter.length-1]+"]\n";
            else
            text+="]\n";
            fileOut.write(text);
            fileOut.close();
            */
                
        }
}

